package ExcelTools

import (
	"ToolLibray/jwtx"
	"bytes"
	"context"
	"fmt"
	"github.com/xuri/excelize/v2"
	"log"
	"property_api/internal/svc"
	"property_api/internal/types"
	"property_service/property_service"
	"strings"

	"github.com/zeromicro/go-zero/core/logx"
)

type ExportLogic struct {
	logx.Logger
	ctx    context.Context
	svcCtx *svc.ServiceContext
}

func NewExportLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ExportLogic {
	return &ExportLogic{
		Logger: logx.WithContext(ctx),
		ctx:    ctx,
		svcCtx: svcCtx,
	}
}

/*
*
导出数据，以及导出模板
*/
func (l *ExportLogic) Export(req *types.ExportFrom) (resp *types.ExcelRes, err error) {
	// 定义一个map，用于存储不同表名的处理函数
	tableHandlers := map[string]func(*types.ExportFrom) ([]map[string]interface{}, []string, error){
		//--------------含层级关系--------------
		//财务科目
		"finance_account_subject": l.HandleFinanceAccountSubject,
		//财务科目
		"财务科目": l.HandleFinanceAccountSubject,
		//资产分类
		"资产分类": l.HandleAssetCategory,
		//科室go
		"科室": l.HandleHospitalDepartment,
		//--------------无层级关系--------------
		//资产信息
		"资产信息": l.HandleAssetBasicInfo,
		//厂商信息
		"厂商信息": l.HandleVendorInfo,
		//资产类型
		"资产类型": l.HandleAssetType,
		//品牌信息
		"品牌信息": l.HandleBrandAddition,
		//产地信息
		"产地信息": l.HandleOriginAddition,
		//财务分类
		"财务分类": l.HandleAssetFinancialCategory,
		//供应商
		"供应商": l.HandleSupplierLevelAddition,
		//厂商
		"厂商": l.HandleSupplierCertType,
	}

	// 根据请求中的表名，获取对应的处理函数
	handler, ok := tableHandlers[req.TableName]
	if !ok {
		return nil, fmt.Errorf("不支持的表名: %s", req.TableName)
	}

	// 调用处理函数，获取数据
	data, headers, err := handler(req)
	if err != nil {
		return nil, err
	}

	// 创建一个新的Excel文件
	f := excelize.NewFile()
	defer func() {
		// 关闭Excel文件
		if err := f.Close(); err != nil {
			log.Println("Failed to close Excel file:", err)
		}
	}()

	// 设置工作表名称
	Sheet := req.TableName
	// 创建工作表
	index, err := f.NewSheet(Sheet)
	if err != nil {
		return nil, fmt.Errorf("创建工作表失败: %v", err)
	}

	/*	// 设置表头
		for col, header := range headers {
			cell, _ := excelize.CoordinatesToCellName(col+1, 1)
			f.SetCellValue(Sheet, cell, header)
		}*/

	// 设置表头
	var cleanedHeaders []string
	// 设置表头
	for col, header := range headers {
		cell, _ := excelize.CoordinatesToCellName(col+1, 1)

		// 检查表头最后一个字符是否为 "*", 如果是则设置红色填充
		if strings.HasSuffix(header, "*") {
			// 设置红色填充
			style, _ := f.NewStyle(&excelize.Style{
				Fill: excelize.Fill{
					Type:    "pattern",
					Color:   []string{"#FF0000"}, // 红色
					Pattern: 1,
				},
			})
			f.SetCellStyle(Sheet, cell, cell, style)

			// 移除表头中的 "*"
			f.SetCellValue(Sheet, cell, header)
			cleanHeader := strings.TrimSuffix(header, "*")
			cleanedHeaders = append(cleanedHeaders, cleanHeader)
		} else {
			f.SetCellValue(Sheet, cell, header)
			cleanedHeaders = append(cleanedHeaders, header)
		}

	}

	// 填充数据
	for rowIdx, row := range data {
		for colIdx, key := range cleanedHeaders {
			// 确保 key 存在于 row 中
			if value, ok := row[key]; ok {
				cell, _ := excelize.CoordinatesToCellName(colIdx+1, rowIdx+2)
				// 确保写入的值是字符串类型，以避免类型问题
				f.SetCellValue(Sheet, cell, fmt.Sprintf("%v", value))
			} else {
				// 调试信息，检查 key 是否存在于 row 中
				fmt.Printf("Key '%s' not found in row: %v\n", key, row)
			}
		}
	}

	f.SetActiveSheet(index)

	// 将 Excel 文件写入缓冲区
	var buf bytes.Buffer
	if _, err := f.WriteTo(&buf); err != nil {
		return nil, fmt.Errorf("写入缓冲区失败: %v", err)
	}
	if len(data) == 0 {
		fmt.Println(fmt.Printf("导出表%s模板成功", req.TableName))
	}
	fmt.Println(fmt.Printf("导出%s表成功,共%d条数据", req.TableName, int64(len(data))))
	return &types.ExcelRes{Data: buf.Bytes()}, nil
}

// HandleFinanceAccountSubject 处理财务科目表的导出
func (l *ExportLogic) HandleFinanceAccountSubject(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	//设置表头，其中*代表必填项
	headers := []string{"父级编码", "科目编码*", "科目名称*", "余额方向(0借/1贷)*", "科目类型(字典值)*"}

	var data []map[string]interface{}
	if req.IsBul != 1 {
		pageRes, err := l.svcCtx.BasicService.FinanceAccountSubjectPage(l.ctx, &property_service.FinanceAccountSubjectPageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.FinanceAccountSubject{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		for _, item := range pageRes.List {
			dataItem := map[string]interface{}{
				"父级编码":        item.ParentCode,
				"科目编码":        item.SubjectCode,
				"科目名称":        item.SubjectName,
				"余额方向(0借/1贷)": item.BalanceDirection,
				"科目类型(字典值)":   item.SubjectType,
			}
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}

// HandleVendorInfo 处理厂商信息表的导出
func (l *ExportLogic) HandleVendorInfo(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{"厂商名称*", "统一社会信用代码", "联系人", "联系电话", "厂商类型", "省份", "城市", "公司地址", "备注"}

	var data []map[string]interface{}
	if req.IsBul != 1 {
		pageRes, err := l.svcCtx.BasicService.VendorInfoPage(l.ctx, &property_service.VendorInfoPageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.VendorInfo{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		for _, item := range pageRes.List {
			dataItem := map[string]interface{}{
				"厂商名称":     item.Name,
				"统一社会信用代码": item.UnifiedCode,
				"联系人":      item.ContactPerson,
				"联系电话":     item.ContactPhone,
				"厂商类型":     item.VendorType,
				"省份":       item.Province,
				"城市":       item.City,
				"公司地址":     item.Address,
				"备注":       item.Remark,
			}
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}

// HandleHospitalDepartment 处理医院科室表的导出
func (l *ExportLogic) HandleHospitalDepartment(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	// 获取用户租户ID
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{"父级编码", "科室编号*", "科室名称*", "科室类型*", "科室负责人", "维修自动处理", "备注"}

	var data []map[string]interface{}
	// 如果不是批量导出
	if req.IsBul != 1 {
		// 调用医院科室分页接口
		pageRes, err := l.svcCtx.BasicService.HospitalDepartmentPage(l.ctx, &property_service.HospitalDepartmentPageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.HospitalDepartment{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		// 遍历接口返回的数据
		for _, item := range pageRes.List {
			// 将数据转换为map格式
			dataItem := map[string]interface{}{
				"父级编码":   item.ParentCode,
				"科室编号":   item.DepartmentCode,
				"科室名称":   item.Name,
				"科室类型":   item.DepartmentType,
				"科室负责人":  item.Director,
				"维修自动处理": item.MaintenanceAuto,
				"备注":     item.Remark,
			}
			// 将map添加到data中
			data = append(data, dataItem)
		}
	}

	// 返回数据和表头
	return data, headers, nil
}

// HandleAssetCategory 处理资产分类表的导出
func (l *ExportLogic) HandleAssetCategory(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	// 获取用户租户ID
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{"父级编码", "分类编号*", "分类名称*", "折旧年限(月)", "生产厂商名称 ", "品牌名称", "单价", "单位", "部件标志", "预防性维护", "备注", "资产类型名称"}

	var data []map[string]interface{}
	// 如果不是批量导出
	if req.IsBul != 1 {
		// 调用资产分类分页查询接口
		pageRes, err := l.svcCtx.BasicService.AssetCategoryPage(l.ctx, &property_service.AssetCategoryPageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.AssetCategory{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		// 遍历查询结果
		for _, item := range pageRes.List {
			// 构造数据项
			dataItem := map[string]interface{}{
				"父级编码":    item.ParentCode,
				"分类编号":    item.CategoryCode,
				"分类名称":    item.Name,
				"折旧年限(月)": item.DepreciationMonths,
				"生产厂商名称":  item.ManufacturerName,
				"品牌名称":    item.BrandName,
				"单价":      item.UnitPrice,
				"单位":      item.Unit,
				"部件标志":    item.IsComponent,
				"预防性维护":   item.NeedMaintenance,
				"备注":      item.Remark,
				"资产类型名称":  item.AssetTypeName,
			}
			// 将数据项添加到数据列表中
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}

// HandleAssetType 处理资产类型表的导出
func (l *ExportLogic) HandleAssetType(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	// 获取用户租户ID
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{"资产类型编码*", "资产类型*", "父级编码", "资产折旧年限", "说明"}

	var data []map[string]interface{}
	// 如果不是批量导出
	if req.IsBul != 1 {
		// 调用服务层获取资产类型分页数据
		pageRes, err := l.svcCtx.BasicService.AssetTypePage(l.ctx, &property_service.AssetTypePageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.AssetType{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		// 遍历分页数据，将数据转换为map格式
		for _, item := range pageRes.List {
			dataItem := map[string]interface{}{
				"资产类型编码": item.Code,
				"资产类型":   item.Name,
				"父级编码":   item.ParentCode,
				"资产折旧年限": item.DepreciationPeriod,
				"说明":     item.Remark,
			}
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}

// HandleBrandAddition 处理品牌信息表的导出
func (l *ExportLogic) HandleBrandAddition(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	// 获取用户租户ID
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{"品牌名称*", "拼音简码", "生产厂家", "电话", "地址", "网址", "联系人"}

	var data []map[string]interface{}
	// 如果不是批量导入
	if req.IsBul != 1 {
		// 调用BrandAdditionPage接口获取品牌列表
		pageRes, err := l.svcCtx.BasicService.BrandAdditionPage(l.ctx, &property_service.BrandAdditionPageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.BrandAddition{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		// 遍历品牌列表，将品牌信息放入data中
		for _, item := range pageRes.List {
			dataItem := map[string]interface{}{
				"品牌名称": item.BrandName,
				"拼音简码": item.PronunciationCode,
				"生产厂家": item.Manufacturer,
				"电话":   item.Phone,
				"地址":   item.Address,
				"网址":   item.Website,
				"联系人":  item.ContactPerson,
			}
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}

// HandleOriginAddition 处理产地附加信息表的导出
func (l *ExportLogic) HandleOriginAddition(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{"产地名称*", "拼音简码", "进口标识（是/否）", "备注"}

	var data []map[string]interface{}
	if req.IsBul != 1 {
		pageRes, err := l.svcCtx.BasicService.OriginAdditionPage(l.ctx, &property_service.OriginAdditionPageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.OriginAddition{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		for _, item := range pageRes.List {
			dataItem := map[string]interface{}{
				"产地名称":      item.OriginName,
				"拼音简码":      item.PronunciationCode,
				"进口标识（是/否）": item.ImportFlag,
				"备注":        item.Remark,
			}
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}

// HandleAssetFinancialCategory 处理资产财务分类表的导出
func (l *ExportLogic) HandleAssetFinancialCategory(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	// 获取用户租户ID
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{"分类编码*", "分类名称*", "拼音简码", "备注"}

	var data []map[string]interface{}
	// 如果不是批量导出
	if req.IsBul != 1 {
		// 调用服务层获取资产财务分类分页数据
		pageRes, err := l.svcCtx.BasicService.AssetFinancialCategoryPage(l.ctx, &property_service.AssetFinancialCategoryPageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.AssetFinancialCategory{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		// 遍历分页数据，将数据转换为map格式
		for _, item := range pageRes.List {
			dataItem := map[string]interface{}{
				"分类编码": item.CategoryCode,
				"分类名称": item.CategoryName,
				"拼音简码": item.PronunciationCode,
				"备注":   item.Remark,
			}
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}

// HandleAssetBasicInfo 处理资产信息表的导出
func (l *ExportLogic) HandleAssetBasicInfo(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{
		//35
		"资产编码*", "资产名称*", "使用状态*", "资产原值*", "资产序列号",
		"变动方式*", "产地", "存放地点", "注册证书编号", "档案编号", "保修到期日(YYYY-MM-DD)",
		"购买日期(YYYY-MM-DD)", "进口日期(YYYY-MM-DD)", "使用日期(YYYY-MM-DD)", "原资产编码", "管理科室*", "是否多使用部门(1是/0否)*", "多使用科室名称（如果多使用部门用;分割）", "使用科室*", "资产负责人*",
		"定位标准", "电子标签", "资产类型*", "规格型号", "品牌", "保修凭证编号", "付款金额", "发票金额",
		"发票编号", "合同编号", "供应商", "生产商", "维保商", "单位", "数量/面积",

		/*// 资产科目副表 ChartOfAccount --资金来源  5
		"固定资产科目（如果多使用部门用;分割）", "累计折旧科目（如果多使用部门用;分割）", "科目（如果多使用部门用;分割）",
		"科目使用科室名称（如果多使用部门用;分割）", "部门金额占比（如果多使用部门用;分割）",*/

		// FundSource 定义资金来源表副表 6
		"自有资金（如果多使用部门用;分割）", "财政基本拨款（如果多使用部门用;分割）", "科教费用（如果多使用部门用;分割）",
		"财政项目拨款（如果多使用部门用;分割）", "其他（如果多使用部门用;分割）",
		"资金使用科室名称（如果多使用部门用;分割）",

		// 折旧信息 10
		"开始折旧日期(YYYY-MM-DD)*", "当前净值", "已折旧月份*", "折旧方式*", "折旧备注", "净残值*", "净残值率",
		"累计折旧额*", "净值*", "预计使用年份（月）",

		// TenderInfo 招标信息 9
		"招标名称", "招标方式", "招标形式", "招标日期(YYYY-MM-DD)", "招标合同编号", "供应商名称", "购买价格", "计划持续时间(天)", "备注",
	}

	var data []map[string]interface{}
	if req.IsBul != 1 {
		pageRes, err := l.svcCtx.AssetService.AssetBasicInfoPage(l.ctx, &property_service.AssetBasicInfoPageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.AssetBasicInfo{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		for _, item := range pageRes.List {
			var SourceAmount1, SourceAmount2, SourceAmount3, SourceAmount4, SourceAmount5, UsageRoom2 string
			/*
				var  FixedAssetSubjects, DepreciationSubjects, Subject, Percentage, UsageRoom1, string
				//通过资产ID查询资产副表
				res, _ := l.svcCtx.AssetService.ChartOfAccountPage(l.ctx, &property_service.ChartOfAccountPageReq{
					Page:  0,
					Limit: 0,
					Where: &property_service.ChartOfAccount{
						AssetID:  item.ID,
						TenantID: tenantID,
					},
				})
				if len(res.List) != 0 {
					// 遍历 res.List 获取每个对象的字段并拼接
					for i, item := range res.List {
						if i > 0 {
							FixedAssetSubjects += ";"
							DepreciationSubjects += ";"
							Subject += ";"
							Percentage += ";"
							UsageRoom1 += ";"
						}
						// 将字段值转换为字符串并拼接
						FixedAssetSubjects += fmt.Sprintf("%s", item.FixedAssetSubjectsName)     //资产科目
						DepreciationSubjects += fmt.Sprintf("%s", item.DepreciationSubjectsName) //折旧科目
						Subject += fmt.Sprintf("%s", item.SubjectName)
						Percentage += fmt.Sprintf("%f", item.Percentage)
						UsageRoom1 += item.UsageRoom
					}
				}*/
			//获取资金来源数据
			FundSource, _ := l.svcCtx.AssetService.FundSourcePage(l.ctx, &property_service.FundSourcePageReq{
				Page:  0,
				Limit: 0,
				Where: &property_service.FundSource{
					AssetID:  item.ID,
					TenantID: tenantID,
				},
			})
			//获取资产资金来源
			if len(FundSource.List) != 0 {
				// 遍历 res.List 获取每个对象的字段并拼接
				for i, item := range FundSource.List {
					if i > 0 {
						SourceAmount1 += ";"
						SourceAmount2 += ";"
						SourceAmount3 += ";"
						SourceAmount4 += ";"
						SourceAmount5 += ";"
						UsageRoom2 += ";"
					}
					// 将字段值转换为字符串并拼接
					SourceAmount1 += fmt.Sprintf("%d", item.SourceAmount1)
					SourceAmount2 += fmt.Sprintf("%d", item.SourceAmount2)
					SourceAmount3 += fmt.Sprintf("%d", item.SourceAmount3)
					SourceAmount4 += fmt.Sprintf("%d", item.SourceAmount4)
					SourceAmount5 += fmt.Sprintf("%d", item.SourceAmount5)
					UsageRoom2 += item.UsageRoom
				}
			}
			//获取折旧信息
			DepreciationInfo, _ := l.svcCtx.AssetService.DepreciationInfoPage(l.ctx, &property_service.DepreciationInfoPageReq{
				Page:  0,
				Limit: 0,
				Where: &property_service.DepreciationInfo{
					AssetID:  item.ID,
					TenantID: tenantID,
				},
			})
			if len(DepreciationInfo.List) == 0 {
				fmt.Println("折旧信息为空")
			}

			//获取招标信息
			TenderInfo, _ := l.svcCtx.AssetService.TenderInfoPage(l.ctx, &property_service.TenderInfoPageReq{
				Page:  0,
				Limit: 0,
				Where: &property_service.TenderInfo{
					AssetID:  item.ID,
					TenantID: tenantID,
				},
			})
			if len(TenderInfo.List) == 0 {
				fmt.Println("招标信息为空")
			}

			// 获取招标信息
			var tenderName, tenderMethod, tenderForm, tenderDate, contractNumber, vendorName, purchasePrice, plannedDuration, remarks string
			if len(TenderInfo.List) > 0 {
				tender := TenderInfo.List[0]
				tenderName = tender.TenderName
				tenderMethod = tender.TenderMethod
				tenderForm = tender.TenderForm
				tenderDate = tender.TenderDate
				contractNumber = tender.ContractNumber
				vendorName = tender.VendorName
				purchasePrice = fmt.Sprintf("%v", tender.PurchasePrice)
				plannedDuration = fmt.Sprintf("%d", tender.PlannedDuration)
				remarks = tender.Remarks
			} else {
				// 可以显式赋空值（也可以省略，默认就是空字符串）
				tenderName = ""
				tenderMethod = ""
				tenderForm = ""
				tenderDate = ""
				contractNumber = ""
				vendorName = ""
				purchasePrice = ""
				plannedDuration = ""
				remarks = ""
			}

			//添加资产信息
			dataItem := map[string]interface{}{
				"资产编码":              item.AssetCode,
				"资产名称":              item.AssetName,
				"使用状态":              item.AssetStatus,
				"资产原值":              item.AssetValue,
				"资产序列号":             item.AssetSerialNo,
				"变动方式":              item.WaysOfChanging,
				"产地":                item.CountryOfOrigin,
				"存放地点":              item.StorageLocation,
				"注册证书编号":            item.RegistrationNo,
				"档案编号":              item.DocumentNo,
				"保修到期日(YYYY-MM-DD)": item.WarrantyPeriod,
				"购买日期(YYYY-MM-DD)":  item.PurchaseDate,
				"进口日期(YYYY-MM-DD)":  item.ImportDate,
				"使用日期(YYYY-MM-DD)":  item.UseDate,
				"原资产编码":             item.OriginalAssetCode,
				"管理科室":              item.ManageRoom,
				"是否多使用部门(1是/0否)":    item.IsManyDepartment,
				"多使用科室名称（如果多使用部门用;分割）": item.ManyDepartmentName,
				"使用科室":   item.UsageRoom,
				"资产负责人":  item.AssetOwner,
				"定位标准":   item.PositionStandard,
				"电子标签":   item.ElectronicTag,
				"资产类型":   item.AssetType,
				"规格型号":   item.AssetModel,
				"品牌":     item.Brand,
				"保修凭证编号": item.WarrantyCertificateNo,
				"付款金额":   item.PaymentAmount,
				"发票金额":   item.InvoiceAmount,
				"发票编号":   item.InvoiceNo,
				"合同编号":   item.ContractNo,
				"供应商":    item.SupplierName,
				"生产商":    item.ManufacturersName,
				"维保商":    item.MaintenanceName,
				"单位":     item.Unit,
				"数量/面积":  item.SlMj,

				/*// 资产科目副表 ChartOfAccount
				"固定资产科目（如果多使用部门用;分割）":   FixedAssetSubjects,
				"累计折旧科目（如果多使用部门用;分割）":   DepreciationSubjects,
				"科目（如果多使用部门用;分割）":       Subject,
				"科目使用科室名称（如果多使用部门用;分割）": UsageRoom1,
				"部门金额占比（如果多使用部门用;分割）":   Percentage,*/

				// FundSource 定义资金来源表副表
				"自有资金（如果多使用部门用;分割）":     SourceAmount1,
				"财政基本拨款（如果多使用部门用;分割）":   SourceAmount2,
				"科教费用（如果多使用部门用;分割）":     SourceAmount3,
				"财政项目拨款（如果多使用部门用;分割）":   SourceAmount4,
				"其他（如果多使用部门用;分割）":       SourceAmount5,
				"资金使用科室名称（如果多使用部门用;分割）": UsageRoom2,

				//折旧信息
				"开始折旧日期(YYYY-MM-DD)": DepreciationInfo.List[0].StartDate,
				"当前净值":               DepreciationInfo.List[0].AssetValue,
				"已折旧月份":              DepreciationInfo.List[0].DepreciatedMonths,
				"折旧方式":               DepreciationInfo.List[0].Method,
				"折旧备注":               DepreciationInfo.List[0].Remark,
				"净残值":                DepreciationInfo.List[0].NetResidueValue,
				"净残值率":               DepreciationInfo.List[0].NetResidueRate,
				"累计折旧额":              DepreciationInfo.List[0].AccumulatedDepreciationValue,
				"净值":                 DepreciationInfo.List[0].NetWorthValue,
				"预计使用年份（月）":          DepreciationInfo.List[0].ExpectedUsefulLife,

				//TenderInfo招标信息
				"招标名称":             tenderName,
				"招标方式":             tenderMethod,
				"招标形式":             tenderForm,
				"招标日期(YYYY-MM-DD)": tenderDate,
				"招标合同编号":           contractNumber,
				"供应商名称":            vendorName,
				"购买价格":             purchasePrice,
				"计划持续时间(天)":        plannedDuration,
				"备注":               remarks,
			}
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}

// HandleSupplierLevelAddition 处理供应商级别信息表的导出
func (l *ExportLogic) HandleSupplierLevelAddition(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{"供应商级别名称*", "供应商人", "供应商电话", "备注", "供应商地址"}

	var data []map[string]interface{}
	if req.IsBul != 1 {
		pageRes, err := l.svcCtx.BasicService.SupplierLevelAdditionPage(l.ctx, &property_service.SupplierLevelAdditionPageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.SupplierLevelAddition{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		for _, item := range pageRes.List {
			dataItem := map[string]interface{}{
				"供应商级别名称": item.SupplierLevelName,
				"供应商人":    item.SupplierPerson,
				"供应商电话":   item.SupplierPhone,
				"备注":      item.Remark,
				"供应商地址":   item.Address,
			}
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}

// HandleSupplierCertType 处理厂商证件类型表的导出
func (l *ExportLogic) HandleSupplierCertType(req *types.ExportFrom) ([]map[string]interface{}, []string, error) {
	tenantID := jwtx.GetUserTenantId64(l.ctx)

	// 设置表头，其中*代表必填项
	headers := []string{"证件名称*", "拼音简码", "备注"}

	var data []map[string]interface{}
	if req.IsBul != 1 {
		pageRes, err := l.svcCtx.BasicService.SupplierCertTypePage(l.ctx, &property_service.SupplierCertTypePageReq{
			Page:  1,
			Limit: 0,
			Where: &property_service.SupplierCertType{
				TenantID: tenantID,
			},
		})
		if err != nil {
			return nil, nil, err
		}

		for _, item := range pageRes.List {
			dataItem := map[string]interface{}{
				"证件名称": item.CertificateName,
				"拼音简码": item.PinyinCode,
				"备注":   item.Remark,
			}
			data = append(data, dataItem)
		}
	}

	return data, headers, nil
}
